package src.application.Doppelkopf;

import java.util.logging.Level;
import java.util.logging.Logger;

/**
 * Die Klasse Tisch lenkt den Spielverlauf
 * @author b.osterholt
 */
public class Tisch extends Thread {
    private char farbe = ' ';
    private int wert = 0;
    int anzV = 0;
    Spielrunde runde;
    Spieler spieler[] = new Spieler[4];

    public Tisch(Spieler[] sp) {
        String handkarten = "";
        spieler = sp;
        runde = new Spielrunde(spieler[0], spieler[1], spieler[2], spieler[3]);
        //Spielbeginn mitteilen & Handkarten als String schreiben; anschl. an den Spieler senden
        for (int i = 0; i < 4; i++) {
            java.util.Arrays.sort(spieler[i].handkarten);
            for (int j = 0; j < 10; j++) {
                handkarten += spieler[i].handkarten[j].getFarbe() + "#" + spieler[i].handkarten[j].getWert() + "#";
            }
            Server.sende(i, 'B', "B#" + handkarten);
            handkarten = "";
        }
    }

    /**
     * Spielrunde beginnen
     */
    public void spiele() {
        String text;
        char typ = ' ';
        int stichAnz = 0;
        int aufspieler = runde.getaufspieler();
        Karte[] stich = new Karte[4];
        boolean[] gewinner;
        System.out.println("spiele()");
        
        while (anzV < 4) { //warte darauf, dass jeder einen Vorbehalt zurückmeldet
            //sleep muss da sein, weils sonst nich laeuft
            
            try {Thread.sleep(50);
                } catch (InterruptedException ex) {
                  Logger.getLogger(Client.class.getName()).log(Level.SEVERE, null, ex);
                }        
        }

        checkVorbehalte();
        while (stichAnz < 10) {
            stichAnz++;
            //Server wartet, schickt dem Aufspieler ein Signal, dass er eine Karte legen soll
            for (int i = 0; i < 4; i++) {
                if (i==0){
                    try {Thread.sleep(50);
                        } catch (InterruptedException ex) {
                        Logger.getLogger(Client.class.getName()).log(Level.SEVERE, null, ex);
                        }     
                }
                Server.sende((aufspieler + i) % 4, 'H', "H#");
                //Karte empfangen 
                while ((text = (Server.empfange((aufspieler + i) % 4))).equals("-1")) {}
                //text = Server.empfange((aufspieler + i) % 4);
                typ = entschluessel(text);
                stich[i] = new Karte(wert, farbe);
            }
            runde.setStich(stich[0], stich[1], stich[2], stich[3]);
            runde.spieleStich();
            aufspieler = runde.getaufspieler();
            
            //kurz schlafen, um den Spielern Zeit zu geben, den Stich zu sehen ;-)
            try {Thread.sleep(500); 
                } catch (InterruptedException ex) {
                  Logger.getLogger(Client.class.getName()).log(Level.SEVERE, null, ex);
                }
            for (int i = 0; i < 4; i++) {
                Server.sende((aufspieler + i) % 4, 'G', "G#"+aufspieler);
            }
            //kurz schlafen, um den Spielern Zeit zu geben, den Stich zu sehen ;-)
            try {Thread.sleep(700); 
                } catch (InterruptedException ex) {
                  Logger.getLogger(Client.class.getName()).log(Level.SEVERE, null, ex);
                }
        }
        gewinner = runde.spielGewinner();
        
        String gew = "";
        for (int i=0; i<gewinner.length; ++i)
        {
            if (gewinner[i])
                gew += spieler[i].getName() +" ";
        }
        gew += "haben gewonnen.";
        
        for (int i=0; i<spieler.length; ++i)
            Server.sende(i, 'R', gew);
        

    }

    public void neueRunde() {
        farbe = ' ';
        wert = 0;
        anzV = 0;
        
        for (int i=0; i < spieler.length; i++){ //Spieler reset
            spieler[i].reset();
        }
        runde.reset(); //Spielrunde neu       
        
        String handkarten = "";
        //Spielbeginn mitteilen & Handkarten als String schreiben; anschl. an den Spieler senden
        for (int i = 0; i < 4; i++) {
            java.util.Arrays.sort(spieler[i].handkarten);
            for (int j = 0; j < 10; j++) {
                handkarten += spieler[i].handkarten[j].getFarbe() + "#" + spieler[i].handkarten[j].getWert() + "#";
            }
            Server.sende(i, 'B', "B#" + handkarten);
            handkarten = "";
        }
        spiele();        
    }
    
    /**
     * Entschluesselt den empfangenen String
     * @param str:  zu entschluesselnder String
     * @return   :  Char, der angibt, was empfangen wurde
     */
    private char entschluessel(String str) {
        String[] split = str.split("#");
        if (split[0].equals("H")) { //Handkarte, die als naechstes gespielt wird, wurde geschickt
            farbe = split[1].toCharArray()[0];
            wert = Integer.parseInt(split[2]);
            return 'H';
        }
        else if (split[0].equals("S")) { //Stichkarte wurde gelegt
            farbe = split[1].toCharArray()[0];
            wert = Integer.parseInt(split[2]);
            return 'S';
        }
        else if (split[0].equals("A")) { //Ansage wurde gemacht
//??????? was muss hier hin....
            return 'A';
        }
        else if (split[0].equals("V")) {
System.out.println("tisch - entschluessel - V");

//???????????????????????????????????            
            return 'V';
        }
        return ' ';
    }

    /**
     * Liest alle Vorbehalte aus und ermittelt den höchsten. Schickt dann die
     * aktuelle Spielart und den Spieler des Solos, Schweins
     *
     * Reihenfolge: - Damensolo - Bubensolo - Fleischlos -------- ab hier werden
     * Schweine mit angesagt! ------ Armut - Hochzeit - Schweine
     * 
     * Spielrunde.setSpielart(int spielart): 0->Normalspiel, 1->Bubensolo, 
     * 2->Damensolo, 3->Fleischlos, 4->Schweine, 5-> Hochzeit, 6-> Hochz + Schw
     */
    private void checkVorbehalte() {
        //spiel = Spielart, sp = Spieler, der spieler möchte
        //schwsp = Spieler mia t Schwein, 
        int spiel = 0, sp = -1, schwsp = -1;

        for (int i = 0; i < spieler.length ; i++) {
            if (spieler[(runde.getaufspieler() + i) % 4].getVorbehalte()[1] != 0) {
                schwsp = i;
            }
            // Normalspiel überprüfen
            if (spieler[(runde.getaufspieler() + i) % 4].getVorbehalte()[0] == 0) {
                continue;
            }
            //wenn andere Spielart höher ist, überspringen
            else if (spieler[(runde.getaufspieler() + i) % 4].getVorbehalte()[0] <= spiel) {
                continue;
            }
            else {
                spiel = spieler[(runde.getaufspieler() + i) % 4].getVorbehalte()[0];
                sp = i;
            }
        }

        System.out.println(spiel +"\t"+ sp + "\t" + schwsp);
        
        // Normalspiel
        if ((spiel == 0) && (sp == -1) && (schwsp == -1)) {
            for (int i = 0; i < spieler.length; i++) {
                Server.sende(i, 'V', "V#N#0#");
            }
            runde.setSpielart(0);
        }
        else {
            // wenn kein Solo gespielt wird, bekannt geben, welcher Spiel Schweine hat
            if ((spiel < 6) && (schwsp != -1)){
                for (int i = 0; i < spieler.length; i++) {
                    Server.sende(i, 'V', "V#S#" + Integer.toString(schwsp) + "#");
                }
                runde.setSpielart(4);
            }
            
        /** case 1: Hochzeit 1. Fremder; case 2: 1. fremder Fehl; 
            case 3: 1. Fremder Trumpf; case 4: Hochzeit 2. Fremder;
            case 5: Fleischlos-Solo; case 6: Buben-Solo; case 7: Damensolo */                        
            String ret = "V#";
            if (spiel > 4) { //Soli
                switch (spiel) {
                    case 7: ret += "D#"; runde.setSpielart(2); break;
                    case 6: ret += "B#"; runde.setSpielart(1); break;
                    case 5: ret += "F#"; runde.setSpielart(3); break;
                }
                ret += Integer.toString(sp)+ "#";
                for (int i = 0; i < spieler.length; i++) {
                    spieler[i].setRe(false);
                }
                spieler[sp].setRe(true);
            } else {
                switch (spiel) {
                    case 1: ret += "H1#"; break;
                    case 2: ret += "H2#"; break;
                    case 3: ret += "H3#"; break;
                    case 4: ret += "H4#"; break;
                }
                ret += Integer.toString(sp) + "#";
                if (schwsp != -1){
                    ret += "S#" + Integer.toString(schwsp) + "#";
                    runde.setSpielart(6);
                }
                else {runde.setSpielart(5);}
            }
                       
            for (int i = 0; i < spieler.length; i++) {
                Server.sende(i, 'V', ret);
            }
        }
    }
}